package com.revelvy.controller;

import com.revelvy.mapper.UsersMapper;
import com.revelvy.utils.JsonWapper;
import com.revelvy.utils.Meta;
import com.revelvy.pojo.Users;
import com.revelvy.utils.RegexProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.regex.Pattern;

/**
 * Author: Revelvy
 */
@Controller
public class UsersController {

    @Autowired
    private UsersMapper usersMapper;

    /**
     * 分页查询用户
     *
     * @param query    查询参数 可以为空
     * @param pagenum  当前页码 不能为空
     * @param pagesize 每页显示条数 不能为空
     * @return jsonWapper { data 数据 {totalpage 总记录数 pagenum 当前页码 users 用户数据集合} meta 操作信息}
     */
    @ResponseBody
    @GetMapping("/users")
    public JsonWapper<HashMap<String, Object>, Meta> queryUsers(String query, Integer pagenum, Integer pagesize) {
        JsonWapper<HashMap<String, Object>, Meta> jsonWapper = new JsonWapper<>();
        Meta meta = new Meta();
        int totalpage;
        ArrayList<Users> usersArrayList;
        pagenum = pagesize * (pagenum - 1);
        HashMap<String, Object> map = new HashMap<>();
        map.put("pagenum", pagenum);
        map.put("pagesize", pagesize);
        query = query.trim();
        if (query.isEmpty()) {
            usersArrayList = usersMapper.queryLimitUsers(map);
            totalpage = usersMapper.queryTotalUsers();
        } else {
            map.put("query", query);
            usersArrayList = usersMapper.queryLimitUsersWithQueryString(map);
            totalpage = usersMapper.queryTotalUsersWithQueryString(map);
        }
        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("totalpage", totalpage);
        hashMap.put("pagenum", pagenum);
        hashMap.put("users", usersArrayList);
        meta.setMsg("用户获取成功");
        meta.setStatus(200);
        jsonWapper.setData(hashMap);
        jsonWapper.setMeta(meta);
        return jsonWapper;
    }

    /**
     * 更新用户状态
     *
     * @param uid  用户id
     * @param type 用户状态
     * @return jsonWapper { data 数据 {users 当前被修改状态的用户信息} meta 操作信息}
     */
    @ResponseBody
    @PutMapping("/users/{uId}/state/{type}")
    public JsonWapper<Users, Meta> updateUsersState(@PathVariable("uId") Integer uid, @PathVariable String type) {
        JsonWapper<Users, Meta> jsonWapper = new JsonWapper<>();
        Meta meta = new Meta();
        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("uid", uid);
        hashMap.put("type", type);
        Integer result = usersMapper.updateUsersState(hashMap);
        Users users = usersMapper.queryUsersById(uid);
        if (result != 1) {
            meta.setMsg("用户状态设置失败");
            meta.setStatus(500);
        } else {
            meta.setMsg("用户状态设置成功");
            meta.setStatus(201);
        }
        jsonWapper.setData(users);
        jsonWapper.setMeta(meta);
        return jsonWapper;
    }

    /**
     * 添加用户
     *
     * @param users 待添加用户
     * @return jsonWapper { data 数据 {users 当前被添加的用户信息} meta 操作信息}
     */
    @ResponseBody
    @PostMapping("/users")
    public JsonWapper<Users, Meta> addUsers(@Validated @RequestBody Users users) {
        JsonWapper<Users, Meta> jsonWapper = new JsonWapper<>();
        Meta meta = new Meta();
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); // 日期格式
        String createTime = dateFormat.format(new Date()); // 按日期格式输出当期时间
        users.setCreate_time(createTime);
        users.setRole_name("超级管理员");
        Integer result = usersMapper.addUsers(users);
        if (result != 1) {
            meta.setMsg("用户创建失败");
            meta.setStatus(500);
        } else {
            meta.setMsg("用户创建成功");
            meta.setStatus(201);
        }
        jsonWapper.setData(users);
        jsonWapper.setMeta(meta);
        return jsonWapper;

    }

    /**
     * 根据id查询用户
     *
     * @param uid 用户id
     * @return jsonWapper { data 数据 {users 当前被查询的用户信息} meta 操作信息}
     */
    @ResponseBody
    @GetMapping("/users/{id}")
    public JsonWapper<Users, Meta> queryUsersById(@Validated @PathVariable("id") Integer uid) {
        JsonWapper<Users, Meta> jsonWapper = new JsonWapper<>();
        Meta meta = new Meta();
        Users users = usersMapper.queryUsersById(uid);
        meta.setMsg("用户查询成功");
        meta.setStatus(200);
        jsonWapper.setData(users);
        jsonWapper.setMeta(meta);
        return jsonWapper;
    }

    /**
     * 更新用户信息
     *
     * @param uid  用户id
     * @param body 请求体 {email 用户邮箱 mobile 用户手机号}
     * @return jsonWapper { data 数据 {users 用户最新信息} meta 操作信息}
     */
    @ResponseBody
    @PutMapping("/users/{id}")
    public JsonWapper<Users, Meta> updateUsersById(@PathVariable("id") Integer uid, @RequestBody HashMap<String, String> body) {
        JsonWapper<Users, Meta> jsonWapper = new JsonWapper<>();
        Meta meta = new Meta();
        HashMap<String, Object> hashMap = new HashMap<>();

//        验证
        String email = body.get("email");
        String mobile = body.get("mobile");
        if (!Pattern.matches(RegexProperties.EMAIL_PATTERN, email)) {
            System.out.println("邮箱！！");
            meta.setMsg("用户更新失败：邮箱格式不正确");
            meta.setStatus(500);
            jsonWapper.setData(null);
            jsonWapper.setMeta(meta);
            return jsonWapper;
        }
        if (!Pattern.matches(RegexProperties.MOBILE_PATTERN, mobile)) {
            System.out.println("手机号！！");
            meta.setMsg("用户更新失败：手机号格式不正确");
            meta.setStatus(500);
            jsonWapper.setData(null);
            jsonWapper.setMeta(meta);
            return jsonWapper;
        }

        hashMap.put("uid", uid);
        hashMap.put("email", email);
        hashMap.put("mobile", mobile);
        Integer result = usersMapper.updateUsersById(hashMap);
        if (result != 1) {
            meta.setMsg("用户更新失败");
            meta.setStatus(500);
        } else {
            meta.setMsg("用户更新成功");
            meta.setStatus(200);
        }
        Users users = usersMapper.queryUsersById(uid);
        jsonWapper.setData(users);
        jsonWapper.setMeta(meta);
        return jsonWapper;
    }

    /**
     * 根据id删除用户
     *
     * @param uid 用户id
     * @return jsonWapper { data 数据 null meta 操作信息}
     */
    @ResponseBody
    @DeleteMapping("/users/{id}")
    public JsonWapper<Users, Meta> deleteUsersById(@PathVariable("id") Integer uid) {
        JsonWapper<Users, Meta> jsonWapper = new JsonWapper<>();
        Meta meta = new Meta();
        Integer result = usersMapper.deleteUsersById(uid);
        if (result != 1) {
            meta.setMsg("用户删除失败");
            meta.setStatus(500);
        } else {
            meta.setMsg("用户删除成功");
            meta.setStatus(200);
        }
        jsonWapper.setData(null);
        jsonWapper.setMeta(meta);
        return jsonWapper;
    }

    /**
     * 分配用户角色
     *
     * @param id   用户id
     * @param body {rid 用户角色id}
     * @return jsonWapper { data 数据 {user 用户最新信息} meta 操作信息}
     */
    @ResponseBody
    @PutMapping("/users/{id}/role")
    public JsonWapper<Users, Meta> updateUserRole(@PathVariable("id") String id, @RequestBody HashMap<String, String> body) {
        JsonWapper<Users, Meta> jsonWapper = new JsonWapper<>();
        Meta meta = new Meta();
        HashMap<String, String> hashMap = new HashMap<>();
        hashMap.put("id", id);
        hashMap.put("rid", body.get("rid"));
        Integer result = usersMapper.updateUserRole(hashMap);
        Users users = usersMapper.queryUsersById(Integer.parseInt(id));
        if (result != 1) {
            meta.setMsg("设置角色失败");
            meta.setStatus(500);
        } else {
            meta.setMsg("设置角色成功");
            meta.setStatus(200);
        }
        jsonWapper.setData(users);
        jsonWapper.setMeta(meta);
        return jsonWapper;
    }
}
